/**
 * @author Kai Salmen / https://kaisalmen.de
 * Development repository: https://github.com/kaisalmen/WWOBJLoader
 */

'use strict';

if (THREE.OBJLoader2 === undefined) {
	THREE.OBJLoader2 = {}
}

if (THREE.LoaderSupport === undefined) console.error('"THREE.LoaderSupport" is not available. "THREE.OBJLoader2" requires it. Please include "LoaderSupport.js" in your HTML.');

/**
 * Use this class to load OBJ data from files or to parse OBJ data from an arraybuffer
 * @class
 *
 * @param {THREE.DefaultLoadingManager} [manager] The loadingManager for the loader to use. Default is {@link THREE.DefaultLoadingManager}
 * @param {THREE.LoaderSupport.ConsoleLogger} logger logger to be used
 */
THREE.OBJLoader2 = (function() {

	var OBJLOADER2_VERSION = '2.2.1';
	var LoaderBase = THREE.LoaderSupport.LoaderBase;
	var Validator = THREE.LoaderSupport.Validator;
	var ConsoleLogger = THREE.LoaderSupport.ConsoleLogger;

	OBJLoader2.prototype = Object.create(THREE.LoaderSupport.LoaderBase.prototype);
	OBJLoader2.prototype.constructor = OBJLoader2;

	function OBJLoader2(manager, logger) {
		THREE.LoaderSupport.LoaderBase.call(this, manager, logger);
		this.logger.logInfo('Using THREE.OBJLoader2 version: ' + OBJLOADER2_VERSION);

		this.materialPerSmoothingGroup = false;
		this.fileLoader = Validator.verifyInput(this.fileLoader, new THREE.FileLoader(this.manager));

		this.workerSupport = null;
		this.terminateWorkerOnLoad = true;
	};

	/**
	 * Tells whether a material shall be created per smoothing group.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {boolean} materialPerSmoothingGroup=false
	 */
	OBJLoader2.prototype.setMaterialPerSmoothingGroup = function(materialPerSmoothingGroup) {
		this.materialPerSmoothingGroup = materialPerSmoothingGroup === true;
	};

	/**
	 * Use this convenient method to load an OBJ file at the given URL. By default the fileLoader uses an arraybuffer.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {string}  url A string containing the path/URL of the .obj file.
	 * @param {callback} onLoad A function to be called after loading is successfully completed. The function receives loaded Object3D as an argument.
	 * @param {callback} [onProgress] A function to be called while the loading is in progress. The argument will be the XMLHttpRequest instance, which contains total and Integer bytes.
	 * @param {callback} [onError] A function to be called if an error occurs during loading. The function receives the error as an argument.
	 * @param {callback} [onMeshAlter] A function to be called after a new mesh raw data becomes available for alteration.
	 * @param {boolean} [useAsync] If true, uses async loading with worker, if false loads data synchronously.
	 */
	OBJLoader2.prototype.load = function(url, onLoad, onProgress, onError, onMeshAlter, useAsync) {
		var scope = this;
		if (!Validator.isValid(onProgress)) {
			var numericalValueRef = 0;
			var numericalValue = 0;
			onProgress = function(event) {
				if (!event.lengthComputable) return;

				numericalValue = event.loaded / event.total;
				if (numericalValue > numericalValueRef) {

					numericalValueRef = numericalValue;
					var output = 'Download of "' + url + '": ' + (numericalValue * 100).toFixed(2) + '%';
					scope.onProgress('progressLoad', output, numericalValue);

				}
			};
		}

		if (!Validator.isValid(onError)) {
			onError = function(event) {
				var output = 'Error occurred while downloading "' + url + '"';
				scope.logger.logError(output + ': ' + event);
				scope.onProgress('error', output, -1);
			};
		}

		this.fileLoader.setPath(this.path);
		this.fileLoader.setResponseType('arraybuffer');
		this.fileLoader.load(url, function(content) {
			if (useAsync) {

				scope.parseAsync(content, onLoad);

			} else {

				var callbacks = new THREE.LoaderSupport.Callbacks();
				callbacks.setCallbackOnMeshAlter(onMeshAlter);
				scope._setCallbacks(callbacks);
				onLoad({
					detail: {
						loaderRootNode: scope.parse(content),
						modelName: scope.modelName,
						instanceNo: scope.instanceNo
					}
				});

			}

		}, onProgress, onError);

	};

	/**
	 * Run the loader according the provided instructions.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {THREE.LoaderSupport.PrepData} prepData All parameters and resources required for execution
	 * @param {THREE.LoaderSupport.WorkerSupport} [workerSupportExternal] Use pre-existing WorkerSupport
	 */
	OBJLoader2.prototype.run = function(prepData, workerSupportExternal) {
		this._applyPrepData(prepData);
		var available = this._checkFiles(prepData.resources);
		if (Validator.isValid(workerSupportExternal)) {

			this.terminateWorkerOnLoad = false;
			this.workerSupport = workerSupportExternal;
			this.logger = workerSupportExternal.logger;

		}
		var scope = this;
		var onMaterialsLoaded = function(materials) {
			scope.builder.setMaterials(materials);

			if (Validator.isValid(available.obj.content)) {

				if (prepData.useAsync) {

					scope.parseAsync(available.obj.content, scope.callbacks.onLoad);

				} else {

					scope.parse(available.obj.content);

				}
			} else {

				scope.setPath(available.obj.path);
				scope.load(available.obj.name, scope.callbacks.onLoad, null, null, scope.callbacks.onMeshAlter, prepData.useAsync);

			}
		};

		this._loadMtl(available.mtl, onMaterialsLoaded, prepData.crossOrigin);
	};

	OBJLoader2.prototype._applyPrepData = function(prepData) {
		THREE.LoaderSupport.LoaderBase.prototype._applyPrepData.call(this, prepData);

		if (Validator.isValid(prepData)) {

			this.setMaterialPerSmoothingGroup(prepData.materialPerSmoothingGroup);

		}
	};

	/**
	 * Parses OBJ data synchronously from arraybuffer or string.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {arraybuffer|string} content OBJ data as Uint8Array or String
	 */
	OBJLoader2.prototype.parse = function(content) {
		this.logger.logTimeStart('OBJLoader2 parse: ' + this.modelName);

		var parser = new Parser();
		parser.setLogConfig(this.logger.enabled, this.logger.debug);
		parser.setMaterialPerSmoothingGroup(this.materialPerSmoothingGroup);
		parser.setUseIndices(this.useIndices);
		parser.setDisregardNormals(this.disregardNormals);
		// sync code works directly on the material references
		parser.setMaterials(this.builder.getMaterials());

		var scope = this;
		var onMeshLoaded = function(payload) {
			var meshes = scope.builder.processPayload(payload);
			var mesh;
			for (var i in meshes) {
				mesh = meshes[i];
				scope.loaderRootNode.add(mesh);
			}
		};
		parser.setCallbackBuilder(onMeshLoaded);
		var onProgressScoped = function(text, numericalValue) {
			scope.onProgress('progressParse', text, numericalValue);
		};
		parser.setCallbackProgress(onProgressScoped);

		if (content instanceof ArrayBuffer || content instanceof Uint8Array) {

			this.logger.logInfo('Parsing arrayBuffer...');
			parser.parse(content);

		} else if (typeof(content) === 'string' || content instanceof String) {

			this.logger.logInfo('Parsing text...');
			parser.parseText(content);

		} else {

			throw 'Provided content was neither of type String nor Uint8Array! Aborting...';

		}
		this.logger.logTimeEnd('OBJLoader2 parse: ' + this.modelName);

		return this.loaderRootNode;
	};

	/**
	 * Parses OBJ content asynchronously from arraybuffer.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {arraybuffer} content OBJ data as Uint8Array
	 * @param {callback} onLoad Called after worker successfully completed loading
	 */
	OBJLoader2.prototype.parseAsync = function(content, onLoad) {
		this.logger.logTimeStart('OBJLoader2 parseAsync: ' + this.modelName);

		var scope = this;
		var scopedOnLoad = function() {
			onLoad({
				detail: {
					loaderRootNode: scope.loaderRootNode,
					modelName: scope.modelName,
					instanceNo: scope.instanceNo
				}
			});
			scope.logger.logTimeEnd('OBJLoader2 parseAsync: ' + scope.modelName);
		};
		var scopedOnMeshLoaded = function(payload) {
			var meshes = scope.builder.processPayload(payload);
			var mesh;
			for (var i in meshes) {
				mesh = meshes[i];
				scope.loaderRootNode.add(mesh);
			}
		};

		this.workerSupport = Validator.verifyInput(this.workerSupport, new THREE.LoaderSupport.WorkerSupport(this.logger));
		var buildCode = function(funcBuildObject, funcBuildSingelton) {
			var workerCode = '';
			workerCode += '/**\n';
			workerCode += '  * This code was constructed by OBJLoader2 buildCode.\n';
			workerCode += '  */\n\n';
			workerCode += funcBuildObject('Validator', Validator);
			workerCode += funcBuildSingelton('ConsoleLogger', 'ConsoleLogger', ConsoleLogger);
			workerCode += funcBuildSingelton('LoaderBase', 'LoaderBase', LoaderBase);
			workerCode += funcBuildObject('Consts', Consts);
			workerCode += funcBuildSingelton('Parser', 'Parser', Parser);
			workerCode += funcBuildSingelton('RawMesh', 'RawMesh', RawMesh);
			workerCode += funcBuildSingelton('RawMeshSubGroup', 'RawMeshSubGroup', RawMeshSubGroup);

			return workerCode;
		};
		this.workerSupport.validate(buildCode, false);
		this.workerSupport.setCallbacks(scopedOnMeshLoaded, scopedOnLoad);
		if (scope.terminateWorkerOnLoad) this.workerSupport.setTerminateRequested(true);

		var materialNames = {};
		var materials = this.builder.getMaterials();
		for (var materialName in materials) {

			materialNames[materialName] = materialName;

		}
		this.workerSupport.run({
			params: {
				useAsync: true,
				materialPerSmoothingGroup: this.materialPerSmoothingGroup,
				useIndices: this.useIndices,
				disregardNormals: this.disregardNormals
			},
			logger: {
				debug: this.logger.debug,
				enabled: this.logger.enabled
			},
			materials: {
				// in async case only material names are supplied to parser
				materials: materialNames
			},
			data: {
				input: content,
				options: null
			}
		});
	};

	/**
	 * Constants used by THREE.OBJLoader2
	 */
	var Consts = {
		CODE_LF: 10,
		CODE_CR: 13,
		CODE_SPACE: 32,
		CODE_SLASH: 47,
		STRING_LF: '\n',
		STRING_CR: '\r',
		STRING_SPACE: ' ',
		STRING_SLASH: '/',
		LINE_F: 'f',
		LINE_G: 'g',
		LINE_L: 'l',
		LINE_O: 'o',
		LINE_S: 's',
		LINE_V: 'v',
		LINE_VT: 'vt',
		LINE_VN: 'vn',
		LINE_MTLLIB: 'mtllib',
		LINE_USEMTL: 'usemtl'
	};

	/**
	 * Parse OBJ data either from ArrayBuffer or string
	 * @class
	 */
	var Parser = (function() {

		var ConsoleLogger = THREE.LoaderSupport.ConsoleLogger;

		function Parser() {
			this.callbackProgress = null;
			this.callbackBuilder = null;

			this.materials = {};
			this.rawMesh = null;
			this.useAsync = false;
			this.materialPerSmoothingGroup = false;
			this.useIndices = false;
			this.disregardNormals = false;

			this.inputObjectCount = 1;
			this.outputObjectCount = 1;
			this.counts = {
				vertices: 0,
				faces: 0,
				doubleIndicesCount: 0
			};
			this.logger = new ConsoleLogger();
			this.totalBytes = 0;
		};

		Parser.prototype.setUseAsync = function(useAsync) {
			this.useAsync = useAsync;
		};

		Parser.prototype.setMaterialPerSmoothingGroup = function(materialPerSmoothingGroup) {
			this.materialPerSmoothingGroup = materialPerSmoothingGroup;
		};

		Parser.prototype.setUseIndices = function(useIndices) {
			this.useIndices = useIndices;
		};

		Parser.prototype.setDisregardNormals = function(disregardNormals) {
			this.disregardNormals = disregardNormals;
		};

		Parser.prototype.setMaterials = function(materials) {
			this.materials = Validator.verifyInput(materials, this.materials);
			this.materials = Validator.verifyInput(this.materials, {});
		};

		Parser.prototype.setCallbackBuilder = function(callbackBuilder) {
			this.callbackBuilder = callbackBuilder;
			if (!Validator.isValid(this.callbackBuilder)) throw 'Unable to run as no "builder" callback is set.';
		};

		Parser.prototype.setCallbackProgress = function(callbackProgress) {
			this.callbackProgress = callbackProgress;
		};

		Parser.prototype.setLogConfig = function(enabled, debug) {
			this.logger.setEnabled(enabled);
			this.logger.setDebug(debug);
		};

		Parser.prototype.configure = function() {
			this.rawMesh = new RawMesh(this.materialPerSmoothingGroup, this.useIndices, this.disregardNormals);

			if (this.logger.isEnabled()) {

				var matKeys = Object.keys(this.materials);
				var matNames = (matKeys.length > 0) ? '\n\tmaterialNames:\n\t\t- ' + matKeys.join('\n\t\t- ') : '\n\tmaterialNames: None';
				var printedConfig = 'OBJLoader2.Parser configuration:' +
					matNames +
					'\n\tuseAsync: ' + this.useAsync +
					'\n\tmaterialPerSmoothingGroup: ' + this.materialPerSmoothingGroup +
					'\n\tuseIndices: ' + this.useIndices +
					'\n\tdisregardNormals: ' + this.disregardNormals +
					'\n\tcallbackBuilderName: ' + this.callbackBuilder.name +
					'\n\tcallbackProgressName: ' + this.callbackProgress.name;
				this.logger.logInfo(printedConfig);
			}
		};

		/**
		 * Parse the provided arraybuffer
		 * @memberOf Parser
		 *
		 * @param {Uint8Array} arrayBuffer OBJ data as Uint8Array
		 */
		Parser.prototype.parse = function(arrayBuffer) {
			this.logger.logTimeStart('OBJLoader2.Parser.parse');
			this.configure();

			var arrayBufferView = new Uint8Array(arrayBuffer);
			var length = arrayBufferView.byteLength;
			this.totalBytes = length;
			var buffer = new Array(128);
			var bufferPointer = 0;
			var slashSpacePattern = new Array(16);
			var slashSpacePatternPointer = 0;
			var code;
			var word = '';
			var i = 0;
			for (; i < length; i++) {

				code = arrayBufferView[i];
				switch (code) {
					case Consts.CODE_SPACE:
						if (word.length > 0) buffer[bufferPointer++] = word;
						slashSpacePattern[slashSpacePatternPointer++] = 0;
						word = '';
						break;

					case Consts.CODE_SLASH:
						if (word.length > 0) buffer[bufferPointer++] = word;
						slashSpacePattern[slashSpacePatternPointer++] = 1;
						word = '';
						break;

					case Consts.CODE_LF:
						if (word.length > 0) buffer[bufferPointer++] = word;
						word = '';
						this.processLine(buffer, bufferPointer, slashSpacePattern, slashSpacePatternPointer, i);
						bufferPointer = 0;
						slashSpacePatternPointer = 0;
						break;

					case Consts.CODE_CR:
						break;

					default:
						word += String.fromCharCode(code);
						break;
				}
			}
			this.finalize(i);
			this.logger.logTimeEnd('OBJLoader2.Parser.parse');
		};

		/**
		 * Parse the provided text
		 * @memberOf Parser
		 *
		 * @param {string} text OBJ data as string
		 */
		Parser.prototype.parseText = function(text) {
			this.logger.logTimeStart('OBJLoader2.Parser.parseText');
			this.configure();

			var length = text.length;
			this.totalBytes = length;
			var buffer = new Array(128);
			var bufferPointer = 0;
			var slashSpacePattern = new Array(16);
			var slashSpacePatternPointer = 0;
			var char;
			var word = '';
			var i = 0;
			for (; i < length; i++) {

				char = text[i];
				switch (char) {
					case Consts.STRING_SPACE:
						if (word.length > 0) buffer[bufferPointer++] = word;
						slashSpacePattern[slashSpacePatternPointer++] = 0;
						word = '';
						break;

					case Consts.STRING_SLASH:
						if (word.length > 0) buffer[bufferPointer++] = word;
						slashSpacePattern[slashSpacePatternPointer++] = 1;
						word = '';
						break;

					case Consts.STRING_LF:
						if (word.length > 0) buffer[bufferPointer++] = word;
						word = '';
						this.processLine(buffer, bufferPointer, slashSpacePattern, slashSpacePatternPointer, i);
						bufferPointer = 0;
						slashSpacePatternPointer = 0;
						break;

					case Consts.STRING_CR:
						break;

					default:
						word += char;
				}
			}
			this.finalize(i);
			this.logger.logTimeEnd('OBJLoader2.Parser.parseText');
		};

		Parser.prototype.processLine = function(buffer, bufferPointer, slashSpacePattern, slashSpacePatternPointer, currentByte) {
			if (bufferPointer < 1) return;

			var countSlashes = function(slashSpacePattern, slashSpacePatternPointer) {
				var slashesCount = 0;
				for (var i = 0; i < slashSpacePatternPointer; i++) {
					slashesCount += slashSpacePattern[i];
				}
				return slashesCount;
			};

			var concatStringBuffer = function(buffer, bufferPointer, slashSpacePattern) {
				var concatBuffer = '';
				if (bufferPointer === 2) {

					concatBuffer = buffer[1];

				} else {

					var bufferLength = bufferPointer - 1;
					for (var i = 1; i < bufferLength; i++) {

						concatBuffer += buffer[i] + (slashSpacePattern[i] === 0 ? ' ' : '/');

					}
					concatBuffer += buffer[bufferLength];

				}
				return concatBuffer;
			};

			var flushStringBuffer = function(buffer, bufferPointer) {
				for (var i = 0; i < bufferPointer; i++) {
					buffer[i] = '';
				}
			};

			switch (buffer[0]) {
				case Consts.LINE_V:
					this.rawMesh.pushVertex(buffer, bufferPointer > 4);
					break;

				case Consts.LINE_VT:
					this.rawMesh.pushUv(buffer);
					break;

				case Consts.LINE_VN:
					this.rawMesh.pushNormal(buffer);
					break;

				case Consts.LINE_F:
					this.rawMesh.processFaces(buffer, bufferPointer, countSlashes(slashSpacePattern, slashSpacePatternPointer));
					break;

				case Consts.LINE_L:
					this.rawMesh.processLines(buffer, bufferPointer, countSlashes(slashSpacePattern, slashSpacePatternPointer));
					break;

				case Consts.LINE_S:
					this.rawMesh.pushSmoothingGroup(buffer[1]);
					flushStringBuffer(buffer, bufferPointer);
					break;

				case Consts.LINE_G:
					// 'g' leads to creation of mesh if valid data (faces declaration was done before), otherwise only groupName gets set
					this.processCompletedMesh(currentByte);
					this.rawMesh.pushGroup(concatStringBuffer(buffer, bufferPointer, slashSpacePattern));
					flushStringBuffer(buffer, bufferPointer);
					break;

				case Consts.LINE_O:
					// 'o' is pure meta-information and does not result in creation of new meshes
					this.rawMesh.pushObject(concatStringBuffer(buffer, bufferPointer, slashSpacePattern));
					flushStringBuffer(buffer, bufferPointer);
					break;

				case Consts.LINE_MTLLIB:
					this.rawMesh.pushMtllib(concatStringBuffer(buffer, bufferPointer, slashSpacePattern));
					flushStringBuffer(buffer, bufferPointer);
					break;

				case Consts.LINE_USEMTL:
					this.rawMesh.pushUsemtl(concatStringBuffer(buffer, bufferPointer, slashSpacePattern));
					flushStringBuffer(buffer, bufferPointer);
					break;

				default:
					break;
			}
		};

		Parser.prototype.createRawMeshReport = function(rawMesh, inputObjectCount) {
			var report = rawMesh.createReport(inputObjectCount);
			return 'Input Object number: ' + inputObjectCount +
				'\n\tObject name: ' + report.objectName +
				'\n\tGroup name: ' + report.groupName +
				'\n\tMtllib name: ' + report.mtllibName +
				'\n\tVertex count: ' + report.vertexCount +
				'\n\tNormal count: ' + report.normalCount +
				'\n\tUV count: ' + report.uvCount +
				'\n\tSmoothingGroup count: ' + report.smoothingGroupCount +
				'\n\tMaterial count: ' + report.mtlCount +
				'\n\tReal RawMeshSubGroup count: ' + report.subGroups;
		};

		Parser.prototype.processCompletedMesh = function(currentByte) {
			var result = this.rawMesh.finalize();
			if (Validator.isValid(result)) {

				if (this.rawMesh.colors.length > 0 && this.rawMesh.colors.length !== this.rawMesh.vertices.length) {

					throw 'Vertex Colors were detected, but vertex count and color count do not match!';

				}
				if (this.logger.isDebug()) this.logger.logDebug(this.createRawMeshReport(this.rawMesh, this.inputObjectCount));
				this.inputObjectCount++;

				this.buildMesh(result, currentByte);
				var progressBytesPercent = currentByte / this.totalBytes;
				this.callbackProgress('Completed [o: ' + this.rawMesh.objectName + ' g:' + this.rawMesh.groupName + '] Total progress: ' + (progressBytesPercent * 100).toFixed(2) + '%', progressBytesPercent);
				this.rawMesh.reset(this.rawMesh.smoothingGroup.splitMaterials);

				return true;

			} else {

				return false;
			}
		};

		Parser.prototype.finalize = function(currentByte) {
			this.logger.logInfo('Global output object count: ' + this.outputObjectCount);
			if (this.processCompletedMesh(currentByte) && this.logger.isEnabled()) {

				var parserFinalReport = 'Overall counts: ' +
					'\n\tVertices: ' + this.counts.vertices +
					'\n\tFaces: ' + this.counts.faces +
					'\n\tMultiple definitions: ' + this.counts.doubleIndicesCount;
				this.logger.logInfo(parserFinalReport);

			}
		};

		/**
		 * RawObjectDescriptions are transformed to too intermediate format that is forwarded to the Builder.
		 * It is ensured that rawObjectDescriptions only contain objects with vertices (no need to check).
		 *
		 * @param result
		 */
		Parser.prototype.buildMesh = function(result, currentByte) {
			var rawObjectDescriptions = result.subGroups;

			var vertexFA = new Float32Array(result.absoluteVertexCount);
			this.counts.vertices += result.absoluteVertexCount / 3;
			this.counts.faces += result.faceCount;
			this.counts.doubleIndicesCount += result.doubleIndicesCount;
			var indexUA = (result.absoluteIndexCount > 0) ? new Uint32Array(result.absoluteIndexCount) : null;
			var colorFA = (result.absoluteColorCount > 0) ? new Float32Array(result.absoluteColorCount) : null;
			var normalFA = (result.absoluteNormalCount > 0) ? new Float32Array(result.absoluteNormalCount) : null;
			var uvFA = (result.absoluteUvCount > 0) ? new Float32Array(result.absoluteUvCount) : null;
			var haveVertexColors = Validator.isValid(colorFA);

			var rawObjectDescription;
			var materialNames = [];

			var createMultiMaterial = (rawObjectDescriptions.length > 1);
			var materialIndex = 0;
			var materialIndexMapping = [];
			var selectedMaterialIndex;
			var materialGroup;
			var materialGroups = [];

			var vertexFAOffset = 0;
			var indexUAOffset = 0;
			var colorFAOffset = 0;
			var normalFAOffset = 0;
			var uvFAOffset = 0;
			var materialGroupOffset = 0;
			var materialGroupLength = 0;

			var materialOrg, material, materialName, materialNameOrg;
			for (var oodIndex in rawObjectDescriptions) {

				if (!rawObjectDescriptions.hasOwnProperty(oodIndex)) continue;
				rawObjectDescription = rawObjectDescriptions[oodIndex];

				materialNameOrg = rawObjectDescription.materialName;
				materialName = materialNameOrg + (haveVertexColors ? '_vertexColor' : '') + (rawObjectDescription.smoothingGroup === 0 ? '_flat' : '');
				materialOrg = this.materials[materialNameOrg];
				material = this.materials[materialName];

				// both original and derived names do not lead to an existing material => need to use a default material
				if (!Validator.isValid(materialOrg) && !Validator.isValid(material)) {

					var defaultMaterialName = haveVertexColors ? 'vertexColorMaterial' : 'defaultMaterial';
					materialOrg = this.materials[defaultMaterialName];
					this.logger.logWarn('object_group "' + rawObjectDescription.objectName + '_' +
						rawObjectDescription.groupName + '" was defined with unresolvable material "' +
						materialNameOrg + '"! Assigning "' + defaultMaterialName + '".');
					materialNameOrg = defaultMaterialName;

					// if names are identical then there is no need for later manipulation
					if (materialNameOrg === materialName) {

						material = materialOrg;
						materialName = defaultMaterialName;

					}

				}
				if (!Validator.isValid(material)) {

					var materialCloneInstructions = {
						materialNameOrg: materialNameOrg,
						materialName: materialName,
						materialProperties: {
							vertexColors: haveVertexColors ? 2 : 0,
							flatShading: rawObjectDescription.smoothingGroup === 0
						}
					};
					var payload = {
						cmd: 'materialData',
						materials: {
							materialCloneInstructions: materialCloneInstructions
						}
					};
					this.callbackBuilder(payload);

					// fake entry for async; sync Parser always works on material references (Builder update directly visible here)
					if (this.useAsync) this.materials[materialName] = materialCloneInstructions;

				}

				if (createMultiMaterial) {

					// re-use material if already used before. Reduces materials array size and eliminates duplicates
					selectedMaterialIndex = materialIndexMapping[materialName];
					if (!selectedMaterialIndex) {

						selectedMaterialIndex = materialIndex;
						materialIndexMapping[materialName] = materialIndex;
						materialNames.push(materialName);
						materialIndex++;

					}
					materialGroupLength = this.useIndices ? rawObjectDescription.indices.length : rawObjectDescription.vertices.length / 3;
					materialGroup = {
						start: materialGroupOffset,
						count: materialGroupLength,
						index: selectedMaterialIndex
					};
					materialGroups.push(materialGroup);
					materialGroupOffset += materialGroupLength;

				} else {

					materialNames.push(materialName);

				}

				vertexFA.set(rawObjectDescription.vertices, vertexFAOffset);
				vertexFAOffset += rawObjectDescription.vertices.length;

				if (indexUA) {

					indexUA.set(rawObjectDescription.indices, indexUAOffset);
					indexUAOffset += rawObjectDescription.indices.length;

				}

				if (colorFA) {

					colorFA.set(rawObjectDescription.colors, colorFAOffset);
					colorFAOffset += rawObjectDescription.colors.length;

				}

				if (normalFA) {

					normalFA.set(rawObjectDescription.normals, normalFAOffset);
					normalFAOffset += rawObjectDescription.normals.length;

				}
				if (uvFA) {

					uvFA.set(rawObjectDescription.uvs, uvFAOffset);
					uvFAOffset += rawObjectDescription.uvs.length;

				}

				if (this.logger.isDebug()) {
					var materialIndexLine = Validator.isValid(selectedMaterialIndex) ? '\n\t\tmaterialIndex: ' + selectedMaterialIndex : '';
					var createdReport = 'Output Object no.: ' + this.outputObjectCount +
						'\n\t\tgroupName: ' + rawObjectDescription.groupName +
						materialIndexLine +
						'\n\t\tmaterialName: ' + rawObjectDescription.materialName +
						'\n\t\tsmoothingGroup: ' + rawObjectDescription.smoothingGroup +
						'\n\t\tobjectName: ' + rawObjectDescription.objectName +
						'\n\t\t#vertices: ' + rawObjectDescription.vertices.length / 3 +
						'\n\t\t#indices: ' + rawObjectDescription.indices.length +
						'\n\t\t#colors: ' + rawObjectDescription.colors.length / 3 +
						'\n\t\t#uvs: ' + rawObjectDescription.uvs.length / 2 +
						'\n\t\t#normals: ' + rawObjectDescription.normals.length / 3;
					this.logger.logDebug(createdReport);
				}

			}

			this.outputObjectCount++;
			this.callbackBuilder({
					cmd: 'meshData',
					progress: {
						numericalValue: currentByte / this.totalBytes
					},
					params: {
						meshName: result.name
					},
					materials: {
						multiMaterial: createMultiMaterial,
						materialNames: materialNames,
						materialGroups: materialGroups
					},
					buffers: {
						vertices: vertexFA,
						indices: indexUA,
						colors: colorFA,
						normals: normalFA,
						uvs: uvFA
					}
				}, [vertexFA.buffer],
				Validator.isValid(indexUA) ? [indexUA.buffer] : null,
				Validator.isValid(colorFA) ? [colorFA.buffer] : null,
				Validator.isValid(normalFA) ? [normalFA.buffer] : null,
				Validator.isValid(uvFA) ? [uvFA.buffer] : null
			);
		};

		return Parser;
	})();

	/**
	 * {@link RawMesh} is only used by {@link Parser}.
	 * The user of OBJLoader2 does not need to care about this class.
	 * It is defined publicly for inclusion in web worker based OBJ loader ({@link THREE.OBJLoader2.WWOBJLoader2})
	 */
	var RawMesh = (function() {

		function RawMesh(materialPerSmoothingGroup, useIndices, disregardNormals) {
			this.vertices = [];
			this.colors = [];
			this.normals = [];
			this.uvs = [];

			this.useIndices = useIndices === true;
			this.disregardNormals = disregardNormals === true;

			this.objectName = '';
			this.groupName = '';
			this.activeMtlName = '';
			this.mtllibName = '';
			this.reset(materialPerSmoothingGroup);
		}

		RawMesh.prototype.reset = function(materialPerSmoothingGroup) {
			// faces are stored according combined index of group, material and smoothingGroup (0 or not)
			this.subGroups = [];
			this.subGroupInUse = null;
			this.smoothingGroup = {
				splitMaterials: materialPerSmoothingGroup === true,
				normalized: -1,
				real: -1
			};
			// this default index is required as it is possible to define faces without 'g' or 'usemtl'
			this.pushSmoothingGroup(1);

			this.doubleIndicesCount = 0;
			this.faceCount = 0;
			this.mtlCount = 0;
			this.smoothingGroupCount = 0;
		};

		RawMesh.prototype.pushVertex = function(buffer, haveVertexColors) {
			this.vertices.push(parseFloat(buffer[1]));
			this.vertices.push(parseFloat(buffer[2]));
			this.vertices.push(parseFloat(buffer[3]));
			if (haveVertexColors) {

				this.colors.push(parseFloat(buffer[4]));
				this.colors.push(parseFloat(buffer[5]));
				this.colors.push(parseFloat(buffer[6]));

			}
		};

		RawMesh.prototype.pushUv = function(buffer) {
			this.uvs.push(parseFloat(buffer[1]));
			this.uvs.push(parseFloat(buffer[2]));
		};

		RawMesh.prototype.pushNormal = function(buffer) {
			this.normals.push(parseFloat(buffer[1]));
			this.normals.push(parseFloat(buffer[2]));
			this.normals.push(parseFloat(buffer[3]));
		};

		RawMesh.prototype.pushGroup = function(groupName) {
			this.groupName = Validator.verifyInput(groupName, '');
		};

		RawMesh.prototype.pushObject = function(objectName) {
			this.objectName = Validator.verifyInput(objectName, '');
		};

		RawMesh.prototype.pushMtllib = function(mtllibName) {
			this.mtllibName = Validator.verifyInput(mtllibName, '');
		};

		RawMesh.prototype.pushUsemtl = function(mtlName) {
			if (this.activeMtlName === mtlName || !Validator.isValid(mtlName)) return;
			this.activeMtlName = mtlName;
			this.mtlCount++;

			this.verifyIndex();
		};

		RawMesh.prototype.pushSmoothingGroup = function(smoothingGroup) {
			var smoothingGroupInt = parseInt(smoothingGroup);
			if (isNaN(smoothingGroupInt)) {
				smoothingGroupInt = smoothingGroup === "off" ? 0 : 1;
			}

			var smoothCheck = this.smoothingGroup.normalized;
			this.smoothingGroup.normalized = this.smoothingGroup.splitMaterials ? smoothingGroupInt : (smoothingGroupInt === 0) ? 0 : 1;
			this.smoothingGroup.real = smoothingGroupInt;

			if (smoothCheck !== smoothingGroupInt) {

				this.smoothingGroupCount++;
				this.verifyIndex();

			}
		};

		RawMesh.prototype.verifyIndex = function() {
			var index = this.activeMtlName + '|' + this.smoothingGroup.normalized;
			this.subGroupInUse = this.subGroups[index];
			if (!Validator.isValid(this.subGroupInUse)) {

				this.subGroupInUse = new RawMeshSubGroup(this.objectName, this.groupName, this.activeMtlName, this.smoothingGroup.normalized);
				this.subGroups[index] = this.subGroupInUse;

			}
		};

		RawMesh.prototype.processFaces = function(buffer, bufferPointer, slashesCount) {
			var bufferLength = bufferPointer - 1;
			var i, length;

			// "f vertex ..."
			if (slashesCount === 0) {

				for (i = 2, length = bufferLength; i < length; i++) {

					this.buildFace(buffer[1]);
					this.buildFace(buffer[i]);
					this.buildFace(buffer[i + 1]);

				}

				// "f vertex/uv ..."
			} else if (bufferLength === slashesCount * 2) {

				for (i = 3, length = bufferLength - 2; i < length; i += 2) {

					this.buildFace(buffer[1], buffer[2]);
					this.buildFace(buffer[i], buffer[i + 1]);
					this.buildFace(buffer[i + 2], buffer[i + 3]);

				}

				// "f vertex/uv/normal ..."
			} else if (bufferLength * 2 === slashesCount * 3) {

				for (i = 4, length = bufferLength - 3; i < length; i += 3) {

					this.buildFace(buffer[1], buffer[2], buffer[3]);
					this.buildFace(buffer[i], buffer[i + 1], buffer[i + 2]);
					this.buildFace(buffer[i + 3], buffer[i + 4], buffer[i + 5]);

				}

				// "f vertex//normal ..."
			} else {

				for (i = 3, length = bufferLength - 2; i < length; i += 2) {

					this.buildFace(buffer[1], undefined, buffer[2]);
					this.buildFace(buffer[i], undefined, buffer[i + 1]);
					this.buildFace(buffer[i + 2], undefined, buffer[i + 3]);

				}

			}
		};


		RawMesh.prototype.buildFace = function(faceIndexV, faceIndexU, faceIndexN) {
			var sgiu = this.subGroupInUse;
			if (this.disregardNormals) faceIndexN = undefined;
			var scope = this;
			var updateRawObjectDescriptionInUse = function() {

				var faceIndexVi = parseInt(faceIndexV);
				var indexPointerV = 3 * (faceIndexVi > 0 ? faceIndexVi - 1 : faceIndexVi + scope.vertices.length / 3);

				var vertices = sgiu.vertices;
				vertices.push(scope.vertices[indexPointerV++]);
				vertices.push(scope.vertices[indexPointerV++]);
				vertices.push(scope.vertices[indexPointerV]);

				var indexPointerC = scope.colors.length > 0 ? indexPointerV : null;
				if (indexPointerC !== null) {

					var colors = sgiu.colors;
					colors.push(scope.colors[indexPointerC++]);
					colors.push(scope.colors[indexPointerC++]);
					colors.push(scope.colors[indexPointerC]);

				}

				if (faceIndexU) {

					var faceIndexUi = parseInt(faceIndexU);
					var indexPointerU = 2 * (faceIndexUi > 0 ? faceIndexUi - 1 : faceIndexUi + scope.uvs.length / 2);
					var uvs = sgiu.uvs;
					uvs.push(scope.uvs[indexPointerU++]);
					uvs.push(scope.uvs[indexPointerU]);

				}
				if (faceIndexN) {

					var faceIndexNi = parseInt(faceIndexN);
					var indexPointerN = 3 * (faceIndexNi > 0 ? faceIndexNi - 1 : faceIndexNi + scope.normals.length / 3);
					var normals = sgiu.normals;
					normals.push(scope.normals[indexPointerN++]);
					normals.push(scope.normals[indexPointerN++]);
					normals.push(scope.normals[indexPointerN]);

				}
			};

			if (this.useIndices) {

				var mappingName = faceIndexV + (faceIndexU ? '_' + faceIndexU : '_n') + (faceIndexN ? '_' + faceIndexN : '_n');
				var indicesPointer = sgiu.indexMappings[mappingName];
				if (Validator.isValid(indicesPointer)) {

					this.doubleIndicesCount++;

				} else {

					indicesPointer = sgiu.vertices.length / 3;
					updateRawObjectDescriptionInUse();
					sgiu.indexMappings[mappingName] = indicesPointer;
					sgiu.indexMappingsCount++;

				}
				sgiu.indices.push(indicesPointer);

			} else {

				updateRawObjectDescriptionInUse();

			}
			this.faceCount++;
		};

		/*
		 * Support for lines with or without texture. First element in indexArray is the line identification
		 * 0: "f vertex/uv		vertex/uv 		..."
		 * 1: "f vertex			vertex 			..."
		 */
		RawMesh.prototype.processLines = function(buffer, bufferPointer, slashCount) {
			var i = 1;
			var length;
			var bufferLength = bufferPointer - 1;

			if (bufferLength === slashCount * 2) {

				for (length = bufferLength - 2; i < length; i += 2) {

					this.vertices.push(parseInt(buffer[i]));
					this.uvs.push(parseInt(buffer[i + 1]));

				}

			} else {

				for (length = bufferLength - 1; i < length; i++) {

					this.vertices.push(parseInt(buffer[i]));

				}

			}
		};

		/**
		 * Clear any empty rawObjectDescription and calculate absolute vertex, normal and uv counts
		 */
		RawMesh.prototype.finalize = function() {
			var rawObjectDescriptionsTemp = [];
			var rawObjectDescription;
			var absoluteVertexCount = 0;
			var absoluteIndexMappingsCount = 0;
			var absoluteIndexCount = 0;
			var absoluteColorCount = 0;
			var absoluteNormalCount = 0;
			var absoluteUvCount = 0;
			var indices;
			for (var name in this.subGroups) {

				rawObjectDescription = this.subGroups[name];
				if (rawObjectDescription.vertices.length > 0) {

					indices = rawObjectDescription.indices;
					if (indices.length > 0 && absoluteIndexMappingsCount > 0) {

						for (var i in indices) indices[i] = indices[i] + absoluteIndexMappingsCount;

					}
					rawObjectDescriptionsTemp.push(rawObjectDescription);
					absoluteVertexCount += rawObjectDescription.vertices.length;
					absoluteIndexMappingsCount += rawObjectDescription.indexMappingsCount;
					absoluteIndexCount += rawObjectDescription.indices.length;
					absoluteColorCount += rawObjectDescription.colors.length;
					absoluteUvCount += rawObjectDescription.uvs.length;
					absoluteNormalCount += rawObjectDescription.normals.length;

				}
			}

			// do not continue if no result
			var result = null;
			if (rawObjectDescriptionsTemp.length > 0) {

				result = {
					name: this.groupName !== '' ? this.groupName : this.objectName,
					subGroups: rawObjectDescriptionsTemp,
					absoluteVertexCount: absoluteVertexCount,
					absoluteIndexCount: absoluteIndexCount,
					absoluteColorCount: absoluteColorCount,
					absoluteNormalCount: absoluteNormalCount,
					absoluteUvCount: absoluteUvCount,
					faceCount: this.faceCount,
					doubleIndicesCount: this.doubleIndicesCount
				};

			}
			return result;
		};

		RawMesh.prototype.createReport = function() {
			var report = {
				objectName: this.objectName,
				groupName: this.groupName,
				mtllibName: this.mtllibName,
				vertexCount: this.vertices.length / 3,
				normalCount: this.normals.length / 3,
				uvCount: this.uvs.length / 2,
				smoothingGroupCount: this.smoothingGroupCount,
				mtlCount: this.mtlCount,
				subGroups: this.subGroups.length
			};

			return report;
		};

		return RawMesh;
	})();

	/**
	 * Descriptive information and data (vertices, normals, uvs) to passed on to mesh building function.
	 * @class
	 *
	 * @param {string} objectName Name of the mesh
	 * @param {string} groupName Name of the group
	 * @param {string} materialName Name of the material
	 * @param {number} smoothingGroup Normalized smoothingGroup (0: flat shading, 1: smooth shading)
	 */
	var RawMeshSubGroup = (function() {

		function RawMeshSubGroup(objectName, groupName, materialName, smoothingGroup) {
			this.objectName = objectName;
			this.groupName = groupName;
			this.materialName = materialName;
			this.smoothingGroup = smoothingGroup;
			this._init();
		}

		RawMeshSubGroup.prototype._init = function() {
			this.vertices = [];
			this.indexMappingsCount = 0;
			this.indexMappings = [];
			this.indices = [];
			this.colors = [];
			this.uvs = [];
			this.normals = [];
		};

		return RawMeshSubGroup;
	})();

	OBJLoader2.prototype._checkFiles = function(resources) {
		var resource;
		var result = {
			mtl: null,
			obj: null
		};
		for (var index in resources) {

			resource = resources[index];
			if (!Validator.isValid(resource.name)) continue;
			if (Validator.isValid(resource.content)) {

				if (resource.extension === 'OBJ') {

					// fast-fail on bad type
					if (!(resource.content instanceof Uint8Array)) throw 'Provided content is not of type arraybuffer! Aborting...';
					result.obj = resource;

				} else if (resource.extension === 'MTL' && Validator.isValid(resource.name)) {

					if (!(typeof(resource.content) === 'string' || resource.content instanceof String)) throw 'Provided  content is not of type String! Aborting...';
					result.mtl = resource;

				} else if (resource.extension === "ZIP") {
					// ignore

				} else {

					throw 'Unidentified resource "' + resource.name + '": ' + resource.url;

				}

			} else {

				// fast-fail on bad type
				if (!(typeof(resource.name) === 'string' || resource.name instanceof String)) throw 'Provided file is not properly defined! Aborting...';
				if (resource.extension === 'OBJ') {

					result.obj = resource;

				} else if (resource.extension === 'MTL') {

					result.mtl = resource;

				} else if (resource.extension === "ZIP") {
					// ignore

				} else {

					throw 'Unidentified resource "' + resource.name + '": ' + resource.url;

				}
			}
		}

		return result;
	};

	/**
	 * Utility method for loading an mtl file according resource description.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {string} url URL to the file
	 * @param {Object} content The file content as arraybuffer or text
	 * @param {function} callbackOnLoad
	 * @param {string} [crossOrigin] CORS value
	 */
	OBJLoader2.prototype.loadMtl = function(url, content, callbackOnLoad, crossOrigin) {
		var resource = new THREE.LoaderSupport.ResourceDescriptor(url, 'MTL');
		resource.setContent(content);
		this._loadMtl(resource, callbackOnLoad, crossOrigin);
	};

	/**
	 * Utility method for loading an mtl file according resource description.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {THREE.LoaderSupport.ResourceDescriptor} resource
	 * @param {function} callbackOnLoad
	 * @param {string} [crossOrigin] CORS value
	 */
	OBJLoader2.prototype._loadMtl = function(resource, callbackOnLoad, crossOrigin) {
		if (THREE.MTLLoader === undefined) console.error('"THREE.MTLLoader" is not available. "THREE.OBJLoader2" requires it for loading MTL files.');
		if (Validator.isValid(resource)) this.logger.logTimeStart('Loading MTL: ' + resource.name);

		var materials = [];
		var scope = this;
		var processMaterials = function(materialCreator) {
			var materialCreatorMaterials = [];
			if (Validator.isValid(materialCreator)) {

				materialCreator.preload();
				materialCreatorMaterials = materialCreator.materials;
				for (var materialName in materialCreatorMaterials) {

					if (materialCreatorMaterials.hasOwnProperty(materialName)) {

						materials[materialName] = materialCreatorMaterials[materialName];

					}
				}
			}

			if (Validator.isValid(resource)) scope.logger.logTimeEnd('Loading MTL: ' + resource.name);
			callbackOnLoad(materials);
		};

		var mtlLoader = new THREE.MTLLoader();
		crossOrigin = Validator.verifyInput(crossOrigin, 'anonymous');
		mtlLoader.setCrossOrigin(crossOrigin);

		// fast-fail
		if (!Validator.isValid(resource) || (!Validator.isValid(resource.content) && !Validator.isValid(resource.url))) {

			processMaterials();

		} else {

			mtlLoader.setPath(resource.path);
			if (Validator.isValid(resource.content)) {

				processMaterials(Validator.isValid(resource.content) ? mtlLoader.parse(resource.content) : null);

			} else if (Validator.isValid(resource.url)) {

				var onError = function(event) {
					var output = 'Error occurred while downloading "' + resource.url + '"';
					scope.logger.logError(output + ': ' + event);
					throw output;
				};

				mtlLoader.load(resource.name, processMaterials, undefined, onError);

			}
		}
	};

	return OBJLoader2;
})();